package com.tensai.study.新概念.函数式编程.基础.java_util_function.function;

import org.junit.Test;

import java.util.function.Function;

/**
 * @author Tensai
 */
public class FunctionTest {


    /**
     * Function<T, T> identity()
     * 不作为函数
     */
    @Test
    public void identity() {
        Function<String, String> function = Function.identity();
        String strValue = testIdentity(function);
        System.out.println(strValue);
    }

    private String testIdentity(Function<String, String> function) {
        return function.apply("hello world");
    }

    /**
     * Function<T,V> andThen(Function<? super R, ? extends V> after) <br />
     * 就是现将传过来的参数执行apply(T t)方法,之后把apply(T t)里面返回的结果再去执行第二个Function函数
     */
    @Test
    public void andThen() {

        System.out.println(testAndThen(2, i -> i * 2 + 1, j -> j * j));
    }

    /**
     * 参数首先作用于before，在作用于after
     *
     * @param i      传入参数
     * @param before 先行函数
     * @param after  后行函数
     * @return 执行结果
     */
    private int testAndThen(int i, Function<Integer, Integer> before, Function<Integer, Integer> after) {
        return before.andThen(after).apply(i);
    }


    /**
     * Function<V,R> compose(Function<? super V,? EXTENDS T> before)<br />
     * 接收一个function类型的函数作为参数
     */
    @Test
    public void compose() {
        System.out.println(testCompose(2, i -> i * 2 + 1, j -> j * j));
    }

    /**
     * @param i      输入
     * @param after  后执行
     * @param before 先执行
     * @return 执行结果
     */
    private int testCompose(int i, Function<Integer, Integer> after, Function<Integer, Integer> before) {
        return after.compose(before).apply(i);
    }

    /**
     * R apply(T t)<br />
     * 将给定的参数应用到这个函数上,传入的参数类型为T返回类型为R
     */
    @Test
    public void apply() {

        System.out.println(testApply(2, i -> i * 2 + 1));
    }

    private int testApply(int i, Function<Integer, Integer> function) {
        return function.apply(i);
    }
}
